#pragma once

#include "../cometa/tuple.hpp"

#include "../cometa.hpp"

#include "../cometa/range.hpp"

#include "../cometa/string.hpp"

#include <algorithm>

#include <ctime>

#include <functional>

#include <sstream>

#include <utility>

#include <vector>

#ifdef TESTO_MPFR

#include <mpfr/mpfr.hpp>

#include <mpfr/mpfr_tostring.hpp>

#endif

#include "../ext/console_colors.hpp"

#include <chrono>

#include <cmath>

#if !defined CLANG_DIAGNOSTIC_PRAGMA

#if defined __clang__

#define TESTO_STRING(str) #str

#define CLANG_DIAGNOSTIC_PRAGMA(pragma) _Pragma(TESTO_STRING(clang diagnostic pragma))

#else

#define CLANG_DIAGNOSTIC_PRAGMA(pragma)

#endif

#endif

CLANG_DIAGNOSTIC_PRAGMA(push)

CLANG_DIAGNOSTIC_PRAGMA(ignored "-Wexit-time-destructors")

CLANG_DIAGNOSTIC_PRAGMA(ignored "-Wpadded")

CLANG_DIAGNOSTIC_PRAGMA(ignored "-Wshadow")

namespace testo

{

using namespace cometa;

#ifdef TESTO_MPFR

using reference_number = mpfr::number;

#else

using reference_number = long double;

#endif

#ifdef TESTO_MPFR

template <typename T>

inline double ulp_distance(const mpfr::number& reference, T test)

{

    if (std::isnan(test) && reference.isnan())

        return 0.0;

    if (std::isinf(test) && (reference.isinfinity() || mpfr::abs(reference) > std::numeric_limits<T>::max()))

    {

        if ((reference < 0 && test < 0) || (reference > 0 && test > 0))

            return 0.0;

        else

            return std::numeric_limits<double>::infinity();

    }

    mpfr::number testreal = test;

    T next                = std::nexttoward(test, std::numeric_limits<long double>::infinity());

    mpfr::number ulp      = testreal - mpfr::number(next);

    return std::abs(static_cast<double>((reference - testreal) / ulp));

}

inline std::string number_to_string(const mpfr::number& reference, int precision)

{

    return mpfr::to_string(reference, precision, 'g');

}

#else

template <typename T>

inline double ulp_distance(long double reference, T test)

{

    if (__builtin_isnan(test) && __builtin_isnan(reference))

        return 0.0;

    if (__builtin_isinf(test) &&

        (__builtin_isinf(reference) || std::fabs(reference) > std::numeric_limits<T>::max()))

    {

        if ((reference < 0 && test < 0) || (reference > 0 && test > 0))

            return 0.0;

        else

            return std::numeric_limits<double>::infinity();

    }

    long double test80 = test;

    T next             = std::nexttoward(test, std::numeric_limits<long double>::infinity());

    long double ulp    = test80 - static_cast<long double>(next);

    return std::abs(static_cast<double>((reference - test80) / ulp));

}

#endif

using namespace console_colors;

template <typename Fn, typename L, typename R>

struct comparison

{

    L left;

    R right;

    Fn cmp;

    comparison(L&& left, R&& right) : left(std::forward<L>(left)), right(std::forward<R>(right)) {}